
#ifndef _MSG_STRUCT_H_
#define _MSG_STRUCT_H_
#include "PublicMacro.h"
//#include "Stdafx.h"

#pragma pack(push,1)


#ifdef WIN32
struct __declspec(dllexport) EASY_DATA_TIME
#else
struct EASY_DATA_TIME
#endif
{
	EASY_DATA_TIME(){ memset(this, 0, sizeof(*this)); }

	int _year;
	int _month;
	int _day;
	int _hour;
	int _min;
	int _sec;
};


// 用户登录
struct CMD_CS_AgentUserLogin
{
	CMD_CS_AgentUserLogin()
	{
		memset(this,0,sizeof(*this));
	}
	int			iVersion;								// 版本号 
	int			iAppId;									// 游戏 100 为 android,103为 ios
	char		szAgentName[USER_NAME_LEN];					// 帐号
	char		szPwd[USER_PASSWORD_LEN];				// 密码
	char		szIp[IP_ADDRES_LEN];					// IP地址(服务器用)
	int			iTrenchId;								// 渠道【推广公司：比如腾讯，360，安桌市场等等】(0:本公司; )渠道增加把注释也加上。
	int			iPlatformNo;							// 1=手机;2=PC;3=网页;
	char		szMachineCode[MACHINE_CODE_LEN];		// 机器序列号
};

// 用户登录
struct CMD_CS_UserLogin
{
	CMD_CS_UserLogin()
	{
		memset(this, 0, sizeof(*this));
	}
	CC_PROP(int, _versionNO, versionNO);						// 版本号
	CC_PROP(int, _appID,	 appID);							// 游戏AppID
	CC_PROP_CHAR(_userAcc,  userAcc,  USER_NAME_LEN);			// 帐号
	CC_PROP_CHAR(_userPass, userPass, USER_PASSWORD_LEN);		// 密码
	CC_PROP_CHAR(_machIp,	machIp,	  IP_ADDRES_LEN);			// IP地址(服务器用)
	CC_PROP(int, _trenchId,	 TrenchId);							// 渠道【推广公司：比如腾讯，360，安桌市场等等】(0:本公司; )渠道增加把注释也加上。
	CC_PROP(int, _platformNO,platformNO);						// 1=手机;2=PC;3=网页;
	CC_PROP_CHAR(_machCode, machCode, MACHINE_CODE_LEN);		// 机器序列号
};

// 版本错误
struct CMD_VerError
{
	CMD_VerError()
	{
		memset(this, 0, sizeof(*this));
	}
	int			iVersion;										//	版本号
	char szPCDownAddr[STR_100_LEN];								//	pc 下载地址
	char szAndrDownAddr[STR_100_LEN];							//	android 下载地址
	char szAppDownAddr[STR_100_LEN];							//	ios 下载地址 
	char szPacketName[GAME_NAME_LEN];							//	包名
};

// 是否开启代理人注册功能
struct CMD_IsAgent
{
	CMD_IsAgent()
	{
		memset(this, 0, sizeof(*this));
	}
	int			iIsAgent;										// 是否开启代理人注册功能
};

// 登录错误
struct CMD_SC_UserLoginFail
{
	CMD_SC_UserLoginFail()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRet;										// 返回状态(0:成功;!0:失败)
	char			szResText[RESULT_TEXT_LEN];					// 返回内容说明
};

// 用户登录成功
// 登录服务器就是干用户登录验证这个事的，不要什么数据都放这里来处理。。。
// Cool.Cat
struct CMD_SC_UserLoginInfo
{
	CMD_SC_UserLoginInfo()
	{
		memset(this, 0, sizeof(*this));
		iRet = -1;
	}
	int				iRet;								// 返回状态(0:成功;1:)
	long long		llUserID;							// 用户ID
	char			szName[USER_NAME_LEN];				// 帐号
	char			szNickName[USER_NAME_LEN];			// 用户呢称
	EASY_DATA_TIME	dtForbidEnterTime;					// 禁止进入时间
	char			szResText[RESULT_TEXT_LEN];			// 返回内容说明

};

struct CMD_SC_AgentUserLoginInfo
{
	CMD_SC_AgentUserLoginInfo()
	{
		memset(this, 0, sizeof(*this));
		iRet = -1;
	}
	int				iRet;								// 返回状态(0:成功;1:)
	long long		llAgentID;							// 用户ID 
	char			szName[USER_NAME_LEN];				// 帐号
	int				nAgentLevel;						// 管理层级 0--运营商 1--代理商 2--推广员
	//EASY_DATA_TIME	dtForbidEnterTime;					// 禁止进入时间
	char			szResText[RESULT_TEXT_LEN];			// 返回内容说明
    int				_playerRechargeScale;						//玩家充值比
}; 


//////////////////////////////////////////////////////////////////////////

struct CMD_CS_GetMobileUserinfo
{
	CMD_CS_GetMobileUserinfo()
	{
		memset(this,0,sizeof(*this));
	}
	int		_agentCode;   //运营商、代理商或推广员ID
};

struct CMD_SC_GetMobileUserinfoResult
{
	CMD_SC_GetMobileUserinfoResult()
	{
		memset(this,0,sizeof(*this));
	}
	int			_retVal;
	char		_remark[100];
	int			_agentCode;//个人账号
	int			_uplineCode;//上线账号
	int			_uplinePercent;//上线占比
	int			_selfPercent;//自己占比
	LONGLONG	_yesterPlayProfit;//昨日总玩益润
	LONGLONG	_yesterRevenue;//昨日税收分成
	LONGLONG	_agentGold;//余额
	int			_lowlinePromoterNum;//直属推广员数
	int			_lowlineUserNum;//直属玩家数
};

//向服务器获取代理人个人信息 错误
struct CMD_SC_GetAgentUserInfoFail
{ 
	CMD_SC_GetAgentUserInfoFail()
	{
		memset(this,0,sizeof(*this));
		iRet = -1;
	}
	int   iRet;                              // 返回值
	char  szResText[RESULT_TEXT_LEN];		 // 返回内容说明
};





//////////////////////////////////////////////////////////////////////////

//修改密码
struct CMD_CS_ChangePassword
{ 
	CMD_CS_ChangePassword()
	{
		memset(this,0,sizeof(*this));
	} 
	int		iUserID ;					  // 帐号 id  
	char	szOldPwd[USER_PASSWORD_LEN];  // 旧密码
	char    szNewPwd[USER_PASSWORD_LEN];  // 新密码
};


//修改密码结果
//struct CMD_SC_ChangePasswordRusult
//{ 
//	CMD_SC_ChangePasswordRusult()
//	{
//		memset(this,0,sizeof(*this));
//		iRet = -1;
//	} 
//	int     iRet;                        // 返回值
//	int		iagent_code ;					 // 帐号 id   
//	char    szResText[RESULT_TEXT_LEN];	 // 返回内容说明 
//};

//获取备注名:
struct CMD_CS_GetRemarkName
{
	CMD_CS_GetRemarkName()
	{
		memset(this,0,sizeof(*this));
	}
	int			_agentCode;
};

//获取备注名成功
struct CMD_SC_GetRemarkNameResult
{
	CMD_SC_GetRemarkNameResult()
	{
		memset(this,0,sizeof(*this));
	}
	int			_errCode;
	int			_lowlineCode;
	char		_lowlineRemarkName[USER_NAME_LEN];
};

struct CMD_CSG_AppToRechageOrExchange	//申请充值或兑奖
{
	CMD_CSG_AppToRechageOrExchange()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_sendAgentCode;			//发起方编号
	int			_revAgentCode;			//接收方编号
	long long 	_rechangeGold;			//充值额度
	int			_operType;			//操作类型 1--充值 2--兑奖
	char		_remark[255];				//备注
};


struct CMD_CSG_AppToRechageOrExchangeResult 	//申请充值或兑奖返回
{
	CMD_CSG_AppToRechageOrExchangeResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_retVal;				//返回值
	int			_requestId;				//返回请求ID
	char		_mailText[100];				//提示
	//int			_requestTime;			//返回请求时间
};

struct CMD_CSG_AppToRechageOrExchangeFail 	//申请充值或兑奖失败
{
	CMD_CSG_AppToRechageOrExchangeFail()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_retVal;
	char		_remark[100];
};

struct CMD_CS_SetPromoterRechargeRatio //设置充值比例
{
	CMD_CS_SetPromoterRechargeRatio()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_agentCode;
	int			_goldPerRmb;
};
struct CMD_SC_SetPromoterRechargeRatioResult   //设置充值比例成功/失败
{
	CMD_SC_SetPromoterRechargeRatioResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_retVal;
	char		_remark[100];
};
struct CMD_CS_GetUserExchangeInfo   //获取个人充值、兑奖、转账查询
{
	CMD_CS_GetUserExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_agentCode;
	char		_selDate[11];
};

struct CMD_SC_GetUserExchangeInfoResult		//获取个人充值、兑奖、转账查询成功
{
    int			_retVal;					//0--成功 1或2  为失败,提示不一样
    char		_remark[100];				//提示
    int			_isSupportType;
	int			_sendCode;
	int			_revCode;
	long long	_gold;
    long long   _rmb;						//R值
	int			_type;
    char		_operDate[11];				//日期
    char		_operTime[9];				//时间
	CMD_SC_GetUserExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
};

struct CMD_CS_GetUserNotExchangeInfo //获取未领取信息
{
	CMD_CS_GetUserNotExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;						//当前登录账号
};

struct CMD_SC_GetUserNotExchangeInfoResult
{
    int			_retVal;
    char		_remark[100];
    int			_msgId;
    int			_agentCode;
    char		_msgContent[255];
    char		_remarkMsg[255];
	CMD_SC_GetUserNotExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    bool operator == (const CMD_SC_GetUserNotExchangeInfoResult& other)
    {
        return( _msgId == other._msgId);
    }
};

struct CMD_CS_GetUserFailExchangeInfo  //获取退回的消息
{
	CMD_CS_GetUserFailExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;                             //当前登录的账号
};

struct CMD_SC_GetUserFailExchangeInfoResult  //获取退回充值、退回兑奖信息成功/失败
{
    int			_retVal;
    char		_remark[100];
    int			_msgId;
    int			_agentCode;
    char		_msgContent[255];
	CMD_SC_GetUserFailExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
	bool operator == (const CMD_SC_GetUserFailExchangeInfoResult& other)
	{
		return(_msgId == other._msgId);
	}
};

struct CMD_CS_SetExchangeInfo  //"领取" 或者 "退回" 充值及兑奖操作
{
	CMD_CS_SetExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_msgId;  //对应数据库的消息ID
    int			_isGet;	 //是否领取
};

struct CMD_SC_SetExchangeInfoResult  //"领取" 或者 "退回" 充值及兑奖操作成功/失败
{
	CMD_SC_SetExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;		// 0--成功 1--失败
    char		_remark[255];	//提示
};

struct CMD_CS_SetReadFailExchangeInfo
{
	CMD_CS_SetReadFailExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_msgId;
};

struct CMD_SC_SetReadFailExchangeInfoResult
{
	CMD_SC_SetReadFailExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[1000];
};


//向服务器获取游戏下载地址
struct CMD_CS_GetGameDownLoadURL
{
    CMD_CS_GetGameDownLoadURL()
    {
        memset(this,0,sizeof(*this));
    }
    int	  iUserID ;					// 运营商帐号 id
    int   iGameID;                  // 游戏id
};

//向服务器获取游戏下载地址 结果
struct CMD_SC_GetGameDownLoadURLResult
{
    CMD_SC_GetGameDownLoadURLResult()
    {
        memset(this,0,sizeof(*this));
        iRet = -1;
    }
    
    int	  iRet;					    // 返回值
    int   iGameID;                  //游戏id
    char  szResText[URL_LEN];		// 返回内容说明
};

//向服务器获取代理人个人管理记录
struct CMD_CS_GetAgentUserManageLog
{
    CMD_CS_GetAgentUserManageLog()
    {
        memset(this,0,sizeof(*this));
    }
    int		iUserID ;					// 帐号 id
    char  szLogTime[USER_NAME_LEN];   // 记录时间 格式："2015-07-27"
};

//向服务器获取代理人个人管理记录 结果
struct CMD_SC_GetAgentUserManageLogResult
{
    CMD_SC_GetAgentUserManageLogResult()
    {
        memset(this,0,sizeof(*this));
        iRet = -1;
    }
    
    int	  iRet;						  // 返回值
    char  szLogTime[USER_NAME_LEN];   // 记录时间
    char  szResText[RESULT_TEXT_LEN]; // 返回内容说明
};

//获取登录账号的下线充值比
struct CMD_CS_GetAgentRechargeRatio
{
	CMD_CS_GetAgentRechargeRatio()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;    //当前登录账号
};

//获取下线充值比成功
struct CMD_SC_GetAgentRechargeRatioResult
{
	CMD_SC_GetAgentRechargeRatioResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
    int			_lowlineCode;  //下线编号
    int			_lowlineRechargeRatio; //下线充值比
};

//获取下线充值比失败
struct CMD_CS_GetAgentRechargeRatioFail
{
	CMD_CS_GetAgentRechargeRatioFail()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;		//返回值 0--成功 1--失败
    char		_remark[255];   //提示
};

//获取下级充值、兑奖信息
struct CMD_CS_GetExchangeList
{
	CMD_CS_GetExchangeList()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;			//登录账号
};

//获取下级充值、兑奖信息成功
struct CMD_SC_GetExchangeListResult
{
	CMD_SC_GetExchangeListResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
    int			_lowlineCode;		//下级编号
    long long	_lowlineGold;		//余额
    long long   _lowlineRecharge;	//充值
    long long   _lowlineReward;		//兑奖
};

//获取下级充值、兑奖信息失败
struct CMD_SC_GetExchangeListFail
{
	CMD_SC_GetExchangeListFail()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
};

//获取单个代理或推广员信息

struct CMD_CS_GetSingleAgentInfo
{
	CMD_CS_GetSingleAgentInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_uplineCode;	//登录账号
    int			_agentCode;		//代理商或推广员编号
};

struct CMD_SC_GetSingleAgentInfoResult
{
	CMD_SC_GetSingleAgentInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int         _retVal;					//返回值 0--成功 1--失败
	char		_remark[100];				//返回提示
	int			_agentCode;					//该代理商或推广员账号
	char		_remarkName[33];			//该代理商或推广员备注名
	int			_agentPercent;				//登录账号占比
	int			_lowlinePercent;			//下线占比
	int			_userNum;					//玩家数量
	int			_agentState;				//状态 0=有效(未解封); 1=无效(已经解封)
	long long	_agentGold;					//余额
	long long	_rechargeVal;				//充值
	long long	_rewardVal;					//兑奖
};

//代理商重置密码
struct CMD_CS_ResetAgentPassword
{
    CMD_CS_ResetAgentPassword()
    {
        memset(this,0,sizeof(*this));
    }
    
    int     llFatherAgentID; // 上线代理 id
    int		llAgentID;		 // 下线代理 id
};

//修改密码结果
struct CMD_SC_ChangePasswordRusult
{
    CMD_SC_ChangePasswordRusult()
    {
        memset(this,0,sizeof(*this));
        iRet = -1;
    }
    int     iRet;                        // 返回值
    int		iagent_code ;					 // 帐号 id
    char    szResText[RESULT_TEXT_LEN];	 // 返回内容说明
};

//解封下级代理
struct Req_unforbid_AgentUser
{
    Req_unforbid_AgentUser()
    {
        memset(this, 0, sizeof(*this));
        iRet = -1;//返回值(0正确;!0错误)
    }
    long long UserId;// 被解禁用户ID
    long long OperatorUserId;// 操作人用户ID
    char szUnForbidReason[32];// 解封原因
    //S->C使用的字段
    int iRet;//返回值(0正确;!0错误)
};

//对下级代理封号
struct Req_forbid_AgentUser
{
    Req_forbid_AgentUser()
    {
        memset(this,0,sizeof(*this));
        iRet = -1;//返回值(0正确;!0错误)
    }
    long long UserId;// 被禁止用户ID
    long long OperatorUserId;// 操作人用户ID
    //char szForbidBeginTime[32];// 开始禁止时间
    //char szForbidEndTime[32];// 结束禁止时间
    char szForbidReason[32];// 封号原因
    //S->C使用的字段
    int iRet;// 返回值(0正确;!0错误)
};

//单个代理或推广员修改资料(备注名)
struct CMD_CS_SetSingleAgentInfo
{
	CMD_CS_SetSingleAgentInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int		    _agentCode;   //推广员或代理商账号
    char			_oldRemarkName[33];  //旧的备注名
    char			_newRemarkName[33];  //新备注名
};


//单个代理或推广员修改资料(备注名)

struct CMD_SC_SetSingleAgentInfoResult
{
	CMD_SC_SetSingleAgentInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_retVal;
	char		_remark[100];
	int			_promoter_id;
	char		_newRemarkName[USER_NAME_LEN];
};

//获取运营商或代理商的分成占比
struct CMD_CS_GetAgentProfitPercent
{
	CMD_CS_GetAgentProfitPercent()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;   //登录账号
};

//获取运营商或代理商的分成占比
struct CMD_SC_GetAgentProfitPercentResult
{
	CMD_SC_GetAgentProfitPercentResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int 			_retVal;
    char 		_remark[100];
    int 			_uplineCode;	//当前查询的对象(运营商/代理商)
    int			_lowlineCode;    //下线代理商或推广员编号
    int			_agentPercent;	 //代理商(运营商)占比
    int			_lowlinePercent; //下线占比
    int			_memberNum;      //推广员或玩家数量
};

//获取运营商或代理商的分成占比

struct CMD_SC_GetAgentProfitPercentFail
{
	CMD_SC_GetAgentProfitPercentFail()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
};

// 用户注册
struct CMD_CS_AgentUserRegister
{
    CMD_CS_AgentUserRegister()
    {
        memset(this,0,sizeof(*this));
    }
    int			iVersion;								// 版本号
    int			iAppId;									// 游戏 100 为 android,103为 ios
    int			iPlatformNo;							// 1=手机;2=PC;3=网页;
    char		szMachineCode[MACHINE_CODE_LEN];		// 机器序列号
    char		szName[USER_NAME_LEN];					// 用户名
    char		szRemark[USER_NAME_LEN];				//备注名
    char		szPwd[USER_PASSWORD_LEN];				// 密码
    char		szIp[IP_ADDRES_LEN];					// IP地址(服务器用)
    char        szRegisterCode[USER_PASSWORD_LEN];      // 注册邀请码
    int			iTrenchId;								// 渠道【推广公司：比如腾讯，360，安桌市场等等】(0:本公司; )渠道增加把注释也加上。
    char        szAgentName[USER_NAME_LEN];				//推荐人 名字
    int         iLowerLevelPercent ;					//下级分成
    int         iSelfPercent ;							//自占分成 
};

// 用户注册状态返回
struct CMD_SC_AgentUserRegisterRet
{
    CMD_SC_AgentUserRegisterRet()
    {
        memset(this,0,sizeof(*this));
        iRet = -1;
    }
    int				iRet;								// 返回值
    char			szName[USER_NAME_LEN];				// 帐号
    char			szPwd[USER_PASSWORD_LEN];			// 密码
    char		szResText[RESULT_TEXT_LEN];			    // 返回内容说明
};

//获取玩家充兑及转账信息
struct CMD_CS_GetLowlineUserInfo
{
	CMD_CS_GetLowlineUserInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;			//登录账号
};

//获取玩家充兑及转账信息
struct CMD_SC_GetLowlineUserInfoResult
{
	CMD_SC_GetLowlineUserInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;		    //0--成功 1--失败
    char		_remark[100];		//提示 注意成功时可能也会提示当前不支持充兑功能或者当前不支持转账功能,甚至提示都不支持,需要显示下
    int			_userId;			//直属玩家ID
    char		_userNickName[33];	//直属玩家昵称
    int			_isSupportType;		//支持类型       0-- 既支持充兑功能,又支持转账功能  1--只支持充兑功能 2--只支持转账功能
    long long	_userGold;
    long long   _userRecharge;
    long long   _userReward;
    long long   _transferIn;
    long long   _transferOut;
};
//获取单个玩家信息
struct CMD_CS_GetLowlinePlayerInfo
{
	CMD_CS_GetLowlinePlayerInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int		_promoterCode;
    int 		_playerId;
};

struct CMD_SC_GetLowlinePlayerInfoResult
{
	CMD_SC_GetLowlinePlayerInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;						//0--成功 1--失败
    char		_remark[100];					//提示
    int			_userId;						//直属玩家ID
    char		_userNickName[USER_NAME_LEN];	//直属玩家昵称
    char		_userRemarkName[USER_NAME_LEN]; //直属玩家备注名
    long long	_userGold;						//余额
    long long   _userRecharge;					//充值
    long long   _userReward;					//兑奖
    int			_state;							//状态 0=有效(未解封); 1=无效(已经解封)
    char		_cellPhone[CELL_PHONE_LEN];		//手机号码
    long long   _transferIn;					//转入
    long long   _transferOut;					//转出
};
//对玩家封号
struct Req_forbid_user
{
    Req_forbid_user()
    {
        memset(this,0,sizeof(*this));
        //iUnForbidGameId = 0;// 被解禁游戏ID 0 代表所有
        iRet = -1;//返回值(0正确;!0错误)
    }
    long long UserId;// 被禁止用户ID
    //int iForbidGameId;// 被禁游戏ID
    long long OperatorUserId;// 操作人用户ID
    //char szForbidBeginTime[32];// 开始禁止时间
    //char szForbidEndTime[32];// 结束禁止时间
    char szForbidReason[32];// 封号原因
    //S->C使用的字段
    int iRet;// 返回值(0正确;!0错误)
};
//解封玩家
struct Req_unforbid_user
{
    Req_unforbid_user()
    {
        memset(this, 0, sizeof(*this));
        //iUnForbidGameId = 0;// 被解禁游戏ID 0 代表所有
        iRet = -1;//返回值(0正确;!0错误)
    }
    long long UserId;// 被解禁用户ID
    //int iUnForbidGameId;// 被解禁游戏ID
    long long OperatorUserId;// 操作人用户ID
    char szUnForbidReason[32];// 解封原因
    //S->C使用的字段
    int iRet;//返回值(0正确;!0错误)
};
//下线玩家重置密码
struct CMD_CS_ResetLowerLinePlayerPassword
{
    CMD_CS_ResetLowerLinePlayerPassword()
    {
        memset(this,0,sizeof(*this));
    }
    
    int             llFatherAgentID; // 上线代理  id
    long long		llUserID ;		 // 下线玩家 id
};
//struct CMD_CS_SetUserPrivateInfo  //设置用户个人资料
//{
//    char		_nickName[USER_NAME_LEN];
//    char		_remarkName[USER_NAME_LEN];
//    char		_cellPhone[CELL_PHONE_LEN];
//};
//设置个人资料
struct CMD_SC_SetUserPrivateInfoResult
{
	CMD_SC_SetUserPrivateInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
};

struct CMD_CS_SetUserPrivateInfo  //设置用户个人资料
{
	CMD_CS_SetUserPrivateInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    int		_uplineCode;
    int 		_playerId;
    char		_nickName[USER_NAME_LEN];
    char		_remarkName[USER_NAME_LEN];
    char		_cellPhone[CELL_PHONE_LEN];
};



//人机对战收税分成
struct CMD_CS_GetManToManGameRevenue
{
	CMD_CS_GetManToManGameRevenue()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;   //登录账号
    int			_uplineCode;  //上线账号
    char		_selDate[11];
    int			_gameId;
    int			_type;		//0--合计 1--代理商 2-- 推广员 3--直属玩家

};

struct CMD_SC_GetManToManGameRevenueResult
{
	CMD_SC_GetManToManGameRevenueResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_retVal;
	char		_remark[100];
	int         _gameId;
	char        _gameName[GAME_NAME_LEN];
	char		_selDate[11];
	int			_uplineCode;			//上线账号 
	long long   _gameRevenue;			//游戏总税收
	int			_lowlineCode;			//下线账号
	long long	_lowlineRevenueRatio;   //下线税收分成(如果是代理,包含其下线)
	long long	_agentRevenueRatio;		//登录账号税收分成
	int			_belongType;			//归属类型 0--合计 运营商账号下(10--运营商身份下的代理商列表 11--代理商下的推广员列表 12--推广员下的玩家列表)   
										//代理商账号下 (20--代理商身份下的推广员列表 21--推广员下的玩家列表)
										//推广员账号下 (30--推广员身份下的直属玩家列表)
};

//获取人机对战总玩数据
struct CMD_CS_GetManToMachPlayProfit
{
	CMD_CS_GetManToMachPlayProfit()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;  //登录账号
    int			_uplineCode;
    char		_selDate[11];
    int			_gameId;
    int			_type;		//0--合计 1--代理商 2-- 推广员3--直属玩家
};

//获取人机对战总玩数据
struct CMD_SC_GetManToMachPlayProfitResult
{
	CMD_SC_GetManToMachPlayProfitResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
    int			_agentCode;
	char		_selDate[11];
    long long   _gamePlayIn;			//游戏总玩入
    long long	_gamePlayOut;			//游戏总玩出
    long long	_gameProfit;			//游戏总盈利
    int			_belongType;            //归属类型 0--合计 运营商账号下(10--运营商身份下的代理商列表 11--代理商下的推广员列表 12--推广员下的玩家列表)
    //代理商账号下 (20--代理商身份下的推广员列表 21--推广员下的玩家列表)
    //推广员账号下 (30--推广员身份下的直属玩家列表)

};

//获取人机对战总玩分成
struct CMD_CS_GetManToMachPlayProfitRatio
{
	CMD_CS_GetManToMachPlayProfitRatio()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_agentCode;  //登录账号
    int			_uplineCode;
    char		_selDate[11];
    int			_gameId;
    int			_type;		//3--自占盈利 1--代理商 2-- 推广员
};
//获取人机对战总玩分成
struct CMD_SC_GetManToMachPlayProfitRatioResult
{
	CMD_SC_GetManToMachPlayProfitRatioResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int			_retVal;
    char		_remark[100];
    long long   _agentRatio;			//登录账号自己分成
    int			_lowlineCode;			//下线账号
    long long   _lowlineRatio;			//下线分成
    long long	_uplineRatio;			//上线分成
    int			_belongType;                //归属类型 0--合计 运营商账号下(10--运营商身份下的代理商列表 11--代理商下的推广员列表 12--推广员下的玩家列表)
    //代理商账号下 (20--代理商身份下的推广员列表 21--推广员下的玩家列表)
    //推广员账号下 (30--推广员身份下的直属玩家列表)

};

//获取每日兑换信息(充值 兑奖 转账)
struct CMD_CS_GetDialyExchangeInfo
{
	CMD_CS_GetDialyExchangeInfo()
	{
		memset(this, 0, sizeof(*this));
	}
    char		_selDate[11];       //选择日期
    int			_agentCode;		//登录账号
    int 			_operType;  //操作类型 1--充值 2--兑奖 3--转账
    int			_type;			//类型  0--运营商 1--代理商 2--推广员
};
//获取每日兑换信息(充值 兑奖 转账)
struct CMD_SC_GetDialyExchangeInfoResult
{
	CMD_SC_GetDialyExchangeInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
    int 			_retVal;
    char			_remark[100];
    int 			_operType;		//操作类型 1--充值 2--兑奖 3--转账
    int			_sendCode;   	//发起方
    int			_revCode;		//接收方
    long long   	_gold;		//总额度
    int				_belongType;    //归属类型(充值 兑奖) 0--运营商记录 运营商账号下(10--运营商身份下的代理商记录 11--代理商下的推广员记录)
    //代理商账号下 (20--代理商记录 21--代理商身份下的推广员记录)
    //推广员账号下 (30--推广员记录)
    //(转账) 1-- 运营商身份操作记录 2--代理商身份操作记录 3--推广员身份操作记录
    
};


struct CMD_CS_GetLowlineInfo
{
	CMD_CS_GetLowlineInfo()
	{
	    memset(this, 0, sizeof(*this));
    }
	int			_agentCode;    //当前登录账号
};

struct CMD_SC_GetLowlineInfoResult
{
	CMD_SC_GetLowlineInfoResult()
	{
		memset(this, 0, sizeof(*this));
	}
	int			_uplineCode;
	int			_lowlineCode;  //下线编号
	int			_lowlineRechargeRatio; //下线充值比
};

// 游戏信息
struct CMD_SC_HALLGAME_LIST
{
    CMD_SC_HALLGAME_LIST()
    {
        memset(this, 0, sizeof(*this));
    }
    int				nGameId;							// 游戏ID
    char			szGameName[GAME_NAME_LEN];			// 游戏名字
    char			szAndrDownAddr[URL_LEN];			// 游戏安卓下载地址
    char			szAppDownAddr[URL_LEN];				// 游戏苹果下载地址
    char			szPacketName[GAME_NAME_LEN];		// 包名
    char			szVersionNO[GAME_NAME_LEN];			// 版本号
    char			szGameIntro[DESCRIPTION_LEN];		// 描述长度
    int				nStartOrder;						// 顺序
    char			szIOSGameName[GAME_NAME_LEN];		//IOS 游戏名字
    int				iGameType;							// 游戏类型

};




//////////////////////////////////////////////////////////////////////////////////////////////
// 游戏信息
struct CMD_SC_GAME_LIST
{
	CMD_SC_GAME_LIST()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRet;								// 返回值
	int				iID;								// 游戏ID
	char			szGameName[GAME_NAME_LEN];			// 游戏名字
	char			szProgressName[PROGRESS_NAME_LEN];	// 游戏进程名字长度
	int				iGameType;							// 游戏类型
	int				iSortVal;							// 排序
};

// 功勋信息
struct CMD_SC_FEATS_LIST
{
	CMD_SC_FEATS_LIST()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iSortId;								// 列表ID
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	char			szNickName[USER_NAME_LEN];				// 用户呢称
	int				iRankingCode;							// 排名编码
	int				iRankingNo;								// 排名
	int				iFeats;									// 功勋
	int				iRewardGold;							// 奖励金币
	int				iIsGet;									// 是否已经领取
};

// 信息
struct CMD_SC_MATCH_LIST
{
	CMD_SC_MATCH_LIST()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iSortId;								// 列表ID
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	char			szNickName[USER_NAME_LEN];				// 用户呢称
	int				iRankingCode;							// 排名编码
	int				iRankingNo;								// 排名
	int				iGameCoin;								// 鱼币
	int				iRewardGold;							// 奖励金币
	int				iIsGet;									// 是否已经领取
};

// 领取功勋奖励
struct CMD_CS_UPD_FEATS_RANKING_REWARD
{
	CMD_CS_UPD_FEATS_RANKING_REWARD()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iSortId;								// 列表ID
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	int				iRankingNo;								// 排名
};

// 领取比赛奖励
struct CMD_CS_UPD_MATCH_RANKING_REWARD
{
	CMD_CS_UPD_MATCH_RANKING_REWARD()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iSortId;								// 列表ID
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	int				iRankingNo;								// 排名
};

// 领取功勋奖励成功
struct CMD_SC_UPD_FEATS_RANKING_SUC
{
	CMD_SC_UPD_FEATS_RANKING_SUC()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	int				iRewardGold;							// 奖励金币
};

// 领取比赛奖励成功
struct CMD_SC_UPD_MATCH_RANKING_SUC
{
	CMD_SC_UPD_MATCH_RANKING_SUC()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iID;									// ID
	long long		lUserID;								// 用户ID
	int				iRewardGold;							// 奖励金币
};

// 领取功勋奖励失败
struct CMD_SC_UPD_FEATS_RANKING_ERR
{
	CMD_SC_UPD_FEATS_RANKING_ERR()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		lUserID;								// 用户ID
	int				iRet;									// 失败原因
};

// 领取比赛奖励失败
struct CMD_SC_UPD_MATCH_RANKING_ERR
{
	CMD_SC_UPD_MATCH_RANKING_ERR()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		lUserID;								// 用户ID
	int				iRet;									// 失败原因
};

// 用户注册
struct CMD_CS_UserRegister
{
	CMD_CS_UserRegister()
	{
		memset(this, 0, sizeof(*this));
	}
	int			iVersion;								// 版本号
	int			iAppId;									// 游戏AppID(捕鱼=1; 三公=2; 估计牛牛是=5;)
	int			iPlatformNo;							// 1=手机;2=PC;3=网页;
	int			iEnterMode;								// 进入方式(0:用户名密码进入[正常输入用户名密码登录]，1:快速进入[游客登录])
	char		szMachineCode[MACHINE_CODE_LEN];		// 机器序列号
	char		szName[USER_NAME_LEN];					// 帐号
	char		szPwd[USER_PASSWORD_LEN];				// 密码
	char		szNickName[USER_NAME_LEN];				// 昵称
	char		szIp[IP_ADDRES_LEN];					// IP地址(服务器用)
	int			iSex;									// 性别
	int			iTrenchId;								// 渠道【推广公司：比如腾讯，360，安桌市场等等】(0:本公司; )渠道增加把注释也加上。
	char        szAgentCode[USER_NAME_LEN];				// 推荐人编码
};

// 用户注册状态
struct CMD_CS_UserRegisterRet
{
	CMD_CS_UserRegisterRet()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRet;								// 返回值
	char			szName[USER_NAME_LEN];				// 帐号
	char			szPwd[USER_PASSWORD_LEN];			// 密码
};

// 获取房间列表
struct CMD_CS_RequestRoomList
{
	CMD_CS_RequestRoomList()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iGameID;							// 游戏ID(比如：1捕鱼; 2斗地主; 3麻将...)
};

// 房间列表
struct CMD_SC_RoomList
{
	CMD_SC_RoomList()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		lParentId;							// 父节点（关卡 1:初级场;2:中级场....）..
	int				iGameID;							// 游戏ID(比如：1捕鱼; 2斗地主; 3麻将...)
	int				iRoomType;							// 游戏类型(1=积分房间、2=金币游戏、3=比赛游戏)..
	int				iRoomId;							// 房间ID
	long long		lRoomTeltComIp;						// 房间的中国电信IP
	long long 		lRoomUnicomIp;						// 房间的中国联通IP
	long long		lRoomMobileIp;						// 房间的中国移动IP
	int				iRoomPort;							// 房间端口
	char			szRoomName[ROOM_NAME_LEN];			// 房间名字
	bool			bAutoSit;							// 是否自动入座(0:不自动，需要手动点坐桌和椅子进入; 1:自动入座，不需要点击椅子号)
	int				iBasePoint;							// 倍率..
	int				iDoorsill;							// 进入门槛(自身金币少于门槛不能进入房间)..
	long long		lMaxDoorsill;						// 最高进入门槛(自身金币少于门槛不能进入房间)..
	int				iTables;							// 房内桌子的数量
	int				iSeatNum;							// 每桌人数，即每桌的座位数量
	int				iEnterTradeGold;					// 报名费(金币)
	int				iEnterTradePoint;					// 报名费(积分)
	int				iRewardGold1;						// 第一名奖励
	int				iRewardGold2;						// 第二名奖励
	int				iPlayerCount;						// 游戏人数
	int				iApplyBankerMinGold;				// 最小上庄金币
	int				iMostToLostMoney;					// 房间最大输钱数
	int				iParm17;							// 庄家本身最少有【x%】金币，才能限制下注，
	int				iParm22;							// 下庄上限【庄家低于x值，系统会自动踢庄家下庄】
	int				iParm23;							// 否是有倍率的房间:(0:没有高倍率,全是1倍. 1:有倍率, 三公是3倍..)
};

// 登录服务器配置
struct CMD_INNER_LoginConfig:public PCK_BASE
{
	// 唯一索引
	CC_PROP(long long,m_llServerIdx,ServerIdx);
	// 监听端口
	CC_PROP(int,m_iServerPort,ServerPort);
	// 数据库端口
	CC_PROP(int,m_iDataBasePort,DataBasePort);
	// 数据库地址
	char m_szDataBaseAddr[IP_ADDRES_LEN];
	// 数据库用户名
	char m_szDataBaseUser[DB_USER_NAME_LEN];
	// 数据库密码
	char m_szDataBasePass[DB_PASS_LEN];
	// 数据库名字
	char m_szDataBaseName[DB_NAME_LEN];
	// 中心服务器IP地址
	char m_szCenterServerAddr[IP_ADDRES_LEN];
	// 中心服务器端口
	CC_PROP(int,m_iCenterServerPort,CenterServerPort);
};
// add end

// 与官方的联系方式
struct CMD_ContactInformation
{
	CMD_ContactInformation()
	{
		memset(this, 0, sizeof(*this));
	}
	char szTelephone[STR_100_LEN]; //电话
	char szCustomerService[STR_100_LEN]; //客服
	char szQQ[STR_100_LEN]; //QQ
	char szWebSite[STR_100_LEN]; //网站
	char szWeChat[STR_100_LEN]; //微信
};


struct TEST_USER_INFOS	// 测试用
{
	TEST_USER_INFOS(){ memset(this, 0, sizeof(*this)); }

	int		iAge;
	char	szName[128];
};

struct TEST_DB_QUERY
{
	TEST_DB_QUERY(){ memset(this, 0, sizeof(*this)); }

	int		iQueryType;		// 查询的类型
	char	szContent[64];	// 内容
};

// 桌子信息
struct CMD_TableInfo_Test
{
	CMD_TableInfo_Test()
	{
		memset(this, 0, sizeof(*this));
		iTableNo = INVAL_TABLE_NO;
	}

	int iTableNo;

#if 1
	char szTablePwd[TABLE_PASSWORD_LEN];	// 桌子密码，是四字节对齐的，没有问题
#else
	char szTablePwd[13];	// 桌子密码，故意不让结构四字节对齐，bFriendEnter 为 int 一切正常，但 bFriendEnter 为 bool 时就有问题
	//           若将 szTablePwd 的长度改成 11 ，是Ok的，一点问题也没有，估计是 11 + 1（bFriendEnter的长度）=12 是4的整数倍，所以没问题；
#endif

	long long	lCreateTableUserId;			// 创建桌子用户

	bool	bFriendEnter;	// 通常服务端批量发送200个消息，客户端就会出现2000或9000标识的错误，批量发送60个消息也会偶尔出错；
	// 2000或9000标识的错误表示消息乱啦
};

//#include "./Switch.h"
//#include "FishUserInfo.h"
#include <map>
using namespace std;

#pragma pack(push,1)
#define  TEST_LONGHU_AGENT
#define ROOM_GAME_TYPE_POINT					(1)						// 积分场
#define ROOM_GAME_TYPE_GOLD						(2)						// 金币场
#define ROOM_GAME_TYPE_MATCH					(3)						// 比赛场

#define TRAJECTORY_CATEGORY						(16)					// 宝路图种类	// version: 20140506
#define TRAJECTORY_RET_MULT						(10)					// 归回倍数
#define TRAJECTORY_CARD_TYPE_NUM				(14)					// 牌型组合种类
#define TRAJECTORY_DETAIL_TYPE1					(21)					// 通杀
#define TRAJECTORY_DETAIL_TYPE2					(6)						// 杀3赔1
#define TRAJECTORY_DETAIL_TYPE3					(10)					// 杀2赔2
#define TRAJECTORY_DETAIL_TYPE4					(15)					// 杀1赔3
#define TRAJECTORY_DETAIL_TYPE5					(21)					// 通赔
//--- 枚举 ---------------------------------------------------------
enum ROOM_STATE	// 房间状态，二进制掩码
{
	RS_CAN_LOGIN = 0x0000000000000001,	// 登录房间
	RS_CAN_SIT = 0x0000000000000002,	// 入座
};

struct REQUEST_ROOM_INFO	// 申请房间信息
{
	REQUEST_ROOM_INFO() { memset(this, 0, sizeof(*this)); }

	int	iRoomId;			// 房间ID，是唯一的。注意前 100 的值归系统内部使用
};

struct CMD_RequestResetRoom	// 申请重房间信息
{
	CMD_RequestResetRoom() { memset(this, 0, sizeof(*this)); }

	int	iRoomId;			// 房间ID，是唯一的。注意前 100 的值归系统内部使用
	long long lUserId;		// 用户ID
};

struct REQUEST_ROOM_ERR	// 申请房间信息失败
{
	REQUEST_ROOM_ERR() { memset(this, 0, sizeof(*this)); }

	int	iRoomId;	// 房间ID，是唯一的。注意前 100 的值归系统内部使用
	int	iRes;		// 失败码
};

// 桌子的框架参数
struct CLIENT_FRAME_PARAM
{
	CLIENT_FRAME_PARAM()
	{
		iMsgBlockSize = 2048;
		iSendHeartbeatTime = 30 * 1000;	// 30 秒，标准默认值;
		iShrinkPoolsTime = 3 * 60 * 1000;	// 标准默认值的（5分钟）

		bAutoReConnect = true;
		iAutoReConnectTime = 2 * 1000;
	}

	int iMsgBlockSize;				// 内核消息块的长度
	long long iSendHeartbeatTime;	// 发送心跳包的时间，单位是 ms
	long long iShrinkPoolsTime;		// 收缩各种池的时间，单位是 ms

	bool bAutoReConnect;			// TRUE 表示断线后自动重连，FALSE 表示断线后不再重连
	int  iAutoReConnectTime;		// 断线重连的间隔时间，单位ms
};

// 连接房管服务器 RMS（RoomMgrServer ）的参数
//struct CLIENT_TO_RMS_PARAM
//{
//	CLIENT_TO_RMS_PARAM(char *IP = "127.0.0.1", int Port = 6150, int MsgBlockSize = 2048, int SendHeartbeatTime = 30 * 1000, int ShrinkPoolsTime = 3 * 60 * 1000, bool AutoReConnect = true, int AutoReConnectTime = 2 * 1000)
//	{
//		_snprintf(szIP, sizeof(szIP)-1, "%s", IP);
//		iPort = Port;
//
//		iMsgBlockSize = MsgBlockSize;
//		iSendHeartbeatTime = SendHeartbeatTime;	// 30 秒，标准默认值;
//		iShrinkPoolsTime = ShrinkPoolsTime;	// 标准默认值的（5分钟）
//
//		bAutoReConnect = AutoReConnect;
//		iAutoReConnectTime = AutoReConnectTime;
//	}
//
//	char szIP[IP_ADDRES_LEN];	// 房间服的IP
//	int	 iPort;					// 房间服的端口
//
//	int iMsgBlockSize;				// 内核消息块的长度
//	long long iSendHeartbeatTime;	// 发送心跳包的时间，单位是 ms
//	long long iShrinkPoolsTime;		// 收缩各种池的时间，单位是 ms
//
//	bool bAutoReConnect;			// TRUE 表示断线后自动重连，FALSE 表示断线后不再重连
//	int  iAutoReConnectTime;		// 断线重连的间隔时间，单位ms
//};

struct ROOM_CONFIG :public PCK_BASE
{
	int		lRoomId;			// 本房间的ID
	int		iLogicThreadNum;	// 房间逻辑任务线程数量
	int		iDbThreadNum;		// 数据库任务线程数量

	char	szRoomMgrIp[IP_ADDRES_LEN];	// 房管IP
	int		RoomMgrPort;				// 房管监听端口

	char	szCenterIp[IP_ADDRES_LEN];	// 中心服务器IP
	int		iCenterPort;				// 中心服务器端口
};


// 服务端的房间信息
struct SERVER_ROOM_INFO
{
	SERVER_ROOM_INFO()
	{
		memset(this, 0, sizeof(*this));

		lRoomTeltComIp = 0x0100007F;	// 1.0.0.127 ，房间的中国电信IP，主要是客户端用这个值。经过 inet_ntoa 解析出来就是 127.0.0.1
		lRoomUnicomIp = 0x0100007F;		// 1.0.0.127 ，房间的中国联通IP ，也包括了网通等
		lRoomMobileIp = 0x0100007F;		// 1.0.0.127 ，房间的中国移动IP

		iRoomPort = 5150;

		iOnlyReadDbIp = 0x6301A8C0;	// 99.1.168.192 经过 inet_ntoa 解析出来就是192.168.1.99
		iOnlyReadDbPort = 3306;

		//iCanEnableRoom = 1;

		iTables = 10;
		iSeatNum = 4;

		//iRoomVer = 0x00000001;
	}

	int			iRes;

	int			iAppId;			// AppId
	long long	lParentId;			// 父节点ID，通常用于树型组件的定位
	int			iGameId;			// 游戏ID
	int			iRoomId;			// 房间ID，是唯一的。注意前 100 的值归系统内部使用

	char		szRoomName[ROOM_NAME_LEN];	// 房间名称
	int			iRoomPort;					// 房间的监听端口

	long long	lRoomTeltComIp;	// 房间的中国电信IP，主要是客户端用这个值
	long long	lRoomUnicomIp;	// 房间的中国联通IP ，也包括了网通等，主要是客户端用这个值
	long long	lRoomMobileIp;	// 房间的中国移动IP，主要是客户端用这个值

	long long	iOnlyReadDbIp;							// 房间相连的只读数据库IP
	char		szOnlyReadDbName[DB_NAME_LEN];			// 房间相连的只读数据库名称，通常是 six_devisions
	char		szOnlyReadDbUserName[DB_USER_NAME_LEN];	// 房间相连的只读数据库用户名称，通常是 root
	char		szOnlyReadDbPass[DB_PASS_LEN];			// 房间相连的只读数据库密码

	int			iOnlyReadDbPort;	// 房间相连的只读数据库监听端口

	/*int			iCanEnableRoom;		// 1 允许启动房控，0 此房间已被禁用
	*/
	int	iRoomType;		// 房间类型，积分房间、2=金币游戏、3=比赛游戏、4=测试类游戏

	int	iTables;		// 房内桌子的数量
	int iSeatNum;		// 每桌人数，即每桌的座位数量

	int	iBasePoint;	// 倍频，10倍区、50倍区、100倍区
	int	iDoorsill;	// 进入的门槛，假设为n ，即需要n的积分或金币才能进入房间。
	long long	lMaxDoorsill;	// 最高进入的门槛。

	long long	lRoomRule;		// 房间规则，如会员房间、地址限制、允许旁观、自动坐下、限制座位、限制同IP
	/*long long	lRoomRuleEx;	// 房间规则扩展

	char		szFightTable[FIGHT_TABLE_NAME_LEN];	// 战斗结果对应的表名：1、金币类游戏通常是 game_money，
	//                     2、比赛类游戏通常是 match_x_x ，
	//                     3、积分游戏如“三人挖坑”是 Cavern ，所有的“三人挖坑”积分游戏都用 Cavern 表

	int				iCanAutoOpenRoom;	// 1 表示允许自动启动房间，0 表示禁止自动启动房间
	EASY_DATA_TIME	stOpenRoomTime;		// 自动启动房间的时间
	int				iCanCloseRoom;		// 1 表示允许自动关闭房间，0 表示禁止自动关闭房间
	EASY_DATA_TIME	stCloseRoomTime;	// 自动关闭房间的时间


	char szRoomMessage[ROOM_MESSAGE_LEN];	// 玩家进入房间时会收到的消息提示。
	char szGameMessage[GAME_MESSAGE_LEN];	// 玩家进入游戏时会收到的消息提示。

	int	iClientVer;	// 客户端程序对应的版本号
	int	iRoomVer;	// 房间程序对应的版本号
	*/
	int	iRoomPeopleCount;

	bool			bAutoSit;									// 是否自动入座
	int				iBeginMode;									// 开始模式(0没有人也开始，1有人进入就开始，2桌子坐满就开始)
	int				iMinPlayer;									// 最少开始人数
	int				iStartNotEnter;								// 游戏开始不能进入(0:不能进入;1:能进入);如:比赛场已经在进行中是不能进入游戏的。
	int				iEnterTradeGold;							// 进入上缴报名金币
	int				iEnterTradePoint;							// 进入上缴报名积分
	int				iEnterPresentBullet;						// 进入赠送子弹
	int				iGameTime;									// 每局最大结束时间

	int				iRewardGold1;								// 奖励金币第一名
	int				iRewardGold2;								// 奖励金币第二名
	int				iRevenueRate;								// 房间收税比率
	int				iMostToLostMoney;							// 房间最大输钱数
	int				iExpRadix;									// 经验基数
	int				iApplyBankerMinGold;						// 最小上庄金币
	//	int				iRoomDirStep;								// 房间驱动步骤(1:由房间来决定桌子走那个步骤;0:桌子自身决定)[龙虎机需要整个房间出相同的牌，所以加了这个]

	int				iParm8;										// 一个版图完成之后，由概率【x%】 决定选择【纯随机局数】
	int				iParm9;										// 选择【纯随机局数】，最小【纯随机局数】
	int				iParm10;									// 选择【纯随机局数】，最大【纯随机局数】
	int				iParm11;									// 前面x个版图，已经出现过的版图不能被抽取；
	//	int				iParm12;									// 庄家出现通杀，【%x】重新发牌
	//	int				iParm13;									// 庄家出现通赔，【%x】重新发牌；
	//	int				iParm14;									// 庄家出现通赔，命中和闲家换牌。【%x】和下注较多的方位换牌
	//	int				iParm15;									// 庄家有【%x】下限杀大赔小，(值越大越有利于庄家)
	//	int				iParm16;									// 庄家有【%x】上限杀大赔小，(值越大越有利于庄家)
	int				iParm17;									// 庄家本身最少有【x%】金币，才能限制下注，
	//	int				iParm18;									// 庄家有【x%】杀小赔大，(值越大越有利于闲家)，
	//	int				iParm19;									// 庄家出现通杀，命中和闲家换牌。【x%】和下注较多的方位换牌，(值越大越有利于闲家)，
	//	int				iParm20;									// 天,地,玄,黄【四口下注相同】模糊系数【x%】
	//	int				iParm21;									// 命中【 x%】，则启动【四口下注相同】处理规则
	int				iParm22;									// 下庄上限【庄家低于x值，系统会自动踢庄家下庄】
	int				iParm23;									// 否是有倍率的房间:(0:没有高倍率,全是1倍. 1:有倍率, 三公是3倍..)
	//
	int				iParm27;									// 龙出现的机率基数
	int				iParm28;									// 虎出现的机率基数
	int				iParm29;									// 和出现的机率基数
	int				iParm30;									// 总局数(天书局数),不能大于最大局数
	int				iParm31;									// 最大局数,(龙+虎+和基数)*X=总场数
};

// 房间信息简化信息
struct SERVER_ROOM_INFO_SIM
{
	SERVER_ROOM_INFO_SIM()
	{
		memset(this, 0, sizeof(*this));
	}
	long long	lParentId;					// 父节点ID，通常用于树型组件的定位
	int			iRoomId;					// 房间ID，是唯一的。注意前 100 的值归系统内部使用
	int			iRoomType;					// 游戏类型: 1=积分房间、2=金币游戏、3=比赛游戏、4=测试类游戏。
	int			iBasePoint;					// 倍频，10倍区、50倍区、100倍区
	long long	lRoomRule;					// 房间规则，如会员房间、地址限制、允许旁观、自动坐下、限制座位、限制同IP(暂时没用上)
	char		szRoomName[ROOM_NAME_LEN];	// 房间名称
	int			iTables;					// 房内桌子的数量
	int			iSeatNum;					// 每桌人数，即每桌的座位数量
	int			iRoomPeopleCount;			// 房间人数

	int			iRevenueRate;				// 房间收税比率
	int			iExpRadix;					// 经验基数
	int			iApplyBankerMinGold;		// 最小上庄金币
	int			iParm17;					// 庄家本身最少有【x%】金币，才能限制下注，
};
//// 客户端的房间信息
//struct CLIENT_ROOM_INFO
//{
//	CLIENT_ROOM_INFO(char *IP = "", int Port = 0, char *Name = "", char *Password = "")
//	{
//		memset(this, 0, sizeof(*this));
//		_snprintf(szIP, sizeof(szIP), "%s", IP);
//		iPort = Port;
//
//		_snprintf(szName, sizeof(szName), "%s", Name);
//		_snprintf(szPassword, sizeof(szPassword), "%s", Password);
//	}
//
//	char szIP[IP_ADDRES_LEN];	// 房间服的IP
//	int	 iPort;					// 房间服的端口
//	char szName[USER_NAME_LEN];			// 用户名
//	char szPassword[USER_PASSWORD_LEN];	// 加密后的密码，例如用 MD5 加密后不可逆的密码
//
//
//};

// 登录房间
struct LOGIN_ROOM
{
	LOGIN_ROOM()
	{
		memset(this, 0, sizeof(*this));
	}
	CC_PROP(long long,_userId, userId);						// 用户ID
	CC_PROP_CHAR(_userName, userName, USER_NAME_LEN);		// 用户名		
	CC_PROP_CHAR(_userPass, userPass, USER_PASSWORD_LEN);	// 加密后的密码，例如用 MD5 加密后不可逆的密码
	CC_PROP(long long, _groupOwnId, groupOwnId);			// 群（场）号，其实就是群（场）主的UserId号
};

// 登录房间
struct LOGIN_ROOM_TO_DB
{
	LOGIN_ROOM_TO_DB()
	{
		memset(this, 0, sizeof(*this));
	}
	long long lUserID;
	char szName[USER_NAME_LEN];			// 用户名
	char szPassword[USER_PASSWORD_LEN];	// 加密后的密码，例如用 MD5 加密后不可逆的密码
	int iRoomId;						// 房间ID
	long long 	iGroupOwnId;		// 群（场）主的 UserId
};

enum USER_STATE	// 用户状态
{
	US_OFFLINE = 0,		// 离线，不在房间里
	US_ONLINE_LEAVE_SIT = 10,		// 在线，在房间里，但离座
	US_ONLINE_SITDOWN = 20,		// 在线，在房间里，在坐，但没举手
	US_ONLINE_SITDOWN_RAISE = 30,		// 在线,在房间里，在坐，已举手
	US_ONLINE_PLAYLING = 40,		// 在游戏中
	US_WAIT_RECONNECT = 50,		// 断线后等待重入
	US_LEAVE_ENTER_TRUST = 60,		// 玩家主动离开进入托管状态
};

// 客户端的用户信息
struct USER_INFO
{
	USER_INFO()
	{
		memset(this, 0, sizeof(*this));

		this->setChannelNo(INVALID_CHANNEL_NO);
		this->setUserId(INVALID_USER_ID);
		this->setTableNo(INVAL_TABLE_NO);
		this->setSeatNo(INVAL_SEAT_NO);
	}

	// 登录帐号
	char				szName[USER_NAME_LEN];
	// 游戏昵称
	char				szNickname[USER_NAME_LEN];
	// 登录密码，MD5 后的值
	char				szPassword[USER_PASSWORD_LEN];
	// 银行密码，MD5 后的值
	char				szBankPassword[USER_PASSWORD_LEN];
	// 身份证号码
	char				szIdentityCard[USER_IDENTITY_CARD_LEN];
	// 用户注册时间
	CC_PROP(EASY_DATA_TIME, m_RegistTime, RegistTime);
	// 最后登陆时间
	CC_PROP(EASY_DATA_TIME, m_LastLoginTime, LastLoginTime);
	// 性别：0男性、1女性
	CC_PROP(int, m_iSex, Sex);
	// 注册 IP
	CC_PROP(long long, m_llRegisterIP, RegisterIP);
	// 最后登陆 IP
	CC_PROP(long long, m_llLastLoginIP, LastLoginIP);
	// 桌号
	CC_PROP(int, m_iTableNo, TableNo);
	// 座位号
	CC_PROP(int, m_iSeatNo, SeatNo);
	// 功勋
	CC_PROP(int, m_iFeats, Feats);

	// 通道号，服务端专用
	CC_PROP(long long, m_llChannelNo, ChannelNo);
	// 用户ID
	CC_PROP(long long, m_llUserId, UserId);
	// 社团ID，社团功能可以包下一些桌子，只有该社团成员才能入坐。
	CC_PROP(long long, m_llClubId, ClubId);
	// 玩家的身份：0:普通用户;1:散仙;2:GM管理权限;4:PC后台管理权限;8:机器人;16:可以编辑聊天语句(充值决定)
	CC_PROP(long long, m_llIdentity, Identity);
	// 身份策略(0普通; 1通杀;2通赔;3杀大赔小)
	CC_PROP(int, m_iIdentityTactics, IdentityTactics);
	// 管理权限（是掩码）：允许发警告消息、允许发游戏信息、禁止其他人游戏、踢玩家下线、允许加减分数、禁止进入银行 等
	CC_PROP(long long, m_llMasterPower, MasterPower);
	// 管理权限，扩展
	CC_PROP(long long, m_llMasterPowerEx, MasterPowerEx);
	// 玩家游戏权限（是掩码）：允许游戏聊天、允许发短信息、许任何旁观 等
	CC_PROP(long long, m_llGamePower, GamePower);
	// 玩家游戏权限，扩展。
	CC_PROP(long long, m_llGamePowerEx, GamePowerEx);
	// 系统提供的头像系列。
	CC_PROP(long long, m_llSysLogoID, SysLogoID);
	// 经验值
	CC_PROP(long long, m_llExperience, Experience);
	// 总登陆次数
	CC_PROP(long long, m_llAllLoginCounts, AllLoginCounts);
	// 登录时的金币值
	CC_PROP(long long, m_llGoldLogin, GoldLogin);
	// 登录时的积分
	CC_PROP(long long, m_llPointLogin, PointLogin);
	// 用户发送ping时间
	CC_PROP(long long, m_llNetGapTime, NetGapTime);
	// 上次启用防沉迷限制的时间
	CC_PROP(long long, m_llAntiAddictionTime, AntiAddictionTime);
	// 用户防沉迷游戏时间
	CC_PROP(long long, m_llAntiAddictionPlayTime, AntiAddictionPlayTime);
	// true:是未成年;false:成年人
	CC_PROP(bool, m_bIsJuveniles, IsJuveniles);
	// 税收
	CC_PROP(long long, m_llRevenue, Revenue);
	// 用户状态
	CC_PROP(USER_STATE, m_UserState, UserState);
	// 禁止进入时间
	CC_PROP(EASY_DATA_TIME, m_dtForbidEnterTime, ForbidEnterTime);
	// 炮管的等级和得分倍率
	CC_PROP(int, m_iRateGun, RateGun);
	CC_PROP(int, m_iRateScore, RateScore);
	// 玩家钻石
	CC_PROP(long long, m_llDiamond, Diamond);
	// 玩家珍珠
	CC_PROP(long long, m_llPearls, Pearls);
	// 玩家彩弹
	CC_PROP(long long, m_llPaintBall, PaintBall);
	// 玩家彩票
	CC_PROP(long long, m_llLottery, Lottery);
	// 群（场）的Id
	CC_PROP(long long, m_iGroupOwnId, GroupOwnId);
	// 群（场）里的桌子数量
	CC_PROP(int, m_iTablesInGroup, TablesInGroup);
	// 群（场）里面当前玩家的数量
	CC_PROP(int, m_iPlayerCount, PlayerCount);
	// 群（场）里面当前玩家的渠道类型，用来确定算法返奖率,0-官方渠道；1-平台渠道；99998-苹果商店
	CC_PROP(int, m_iChannelType, ChannelType);
	// 兑换比例
	CC_PROP(int, m_nTransferRatio, TransferRatio);
};

// 登录房间成功
struct LOGIN_ROOM_SUCC
{
	LOGIN_ROOM_SUCC()
	{
		memset(this, 0, sizeof(*this));
	}
	USER_INFO userInfo;			// 用户信息
};

struct RECOME_AFTER_CUT	// 断线重入
{
	RECOME_AFTER_CUT()
	{
		memset(this, 0, sizeof(*this));

		iTableNo = INVAL_TABLE_NO;
		iSeatNo = INVAL_SEAT_NO;
		bAlreadyInRoom = true;
	}

	int	 iErrCode;	// 若登录是成功，返回0值。
	// 若是登录失败，返回非0值的错误码如下：

	int	 iPort;				// 房间服的端口

	bool bAlreadyInRoom;	// 已经在房间里啦
	int iTableNo;	// 桌号
	int iSeatNo;	// 座位号

	char szName[USER_NAME_LEN];			// 用户名
};

// 登录房间失败
struct LOGIN_ROOM_FAIL
{
	enum
	{
		ERR_CAN_NOT_LOGIN = 10,	// 房间禁止登录状态
		ERR_01 = 20,				// 用户名与密码不符，或不存在该用户
		ERR_02 = 30,				// 用户名不唯一
		ERR_30 = 40,				// 服务骨骼增加用户失败
		ERR_FORBID_ENTER_TIME = 50,	// 禁止进入
		ERR_ROOM_FULL = 60,			// 房间已经满了
		ERR_NOT_BIND_ROOM = 70,		// 玩家要进入的渔场未与本房间绑定
		ERR_DISABLE_MACHINE = 80,		// 爆机

		ERR_FREE_TABLE_NOT_ENOUGH = 220, // 空闲桌子不够
		ERR_FREE_SEAT_NOT_ENOUGH = 221,  // 空闲座位不够
		ERR_FREE_GROUP_NOT_ENOUGH = 230, // 空闲群（场）不够
		ERR_EXIST_GROUP = 240,			 // 已经存在该群（场）
		ERR_NOT_EXIST_GROUP = 250,		 // 不存在该群（场）
	};

	LOGIN_ROOM_FAIL() { memset(this, 0, sizeof(*this)); }

	int	 iErrCode;	// 若登录是成功，返回0值。
	// 若是登录失败，返回非0值的错误码如下：
	EASY_DATA_TIME dtForbidEnterTime;
	char szRetText[RESULT_TEXT_LEN];// 返回文本
};

// 离开房间的结果
struct LEAVE_ROOM_RESULT
{
	LEAVE_ROOM_RESULT()
	{
		memset(this, 0, sizeof(*this));
		lUserId = INVALID_USER_ID;
		iTableNo = INVAL_TABLE_NO;
		iSeatNo = INVAL_SEAT_NO;
	}
	long long			lUserId;								// 用户ID
	int					iTableNo;								// 桌号
	int					iSeatNo;								// 座位号
};

// 无此管理权限
struct MANAGER_POWER_ERR
{
	MANAGER_POWER_ERR()
	{
		iWantPower = 0;
	}
	int iWantPower;		// 想施加的权限
};

// 踢玩家离房
struct TICK_USER_OUT_ROOM
{
	enum
	{
		TUOR_NO_FIND = 10,			// 房内无此玩家，可能他还没登录房间
		TUOR_TABLE_ERR = 15,		// 桌号非法
		TUOR_SEAT_NO_USER = 20,		// 座号上没有人
	};

	enum
	{
		TICK_BY_TABLE_SEAT = 10,	// 按桌号、座号踢
		TICK_BY_NAME = 20,			// 按名字踢
		TICK_BY_TABLE = 30,			// 按桌号踢，踢一整桌人离房
		TICK_BY_ALL = 40,			// 踢所有的人离房
	};

	TICK_USER_OUT_ROOM()
	{
		iRes = 0;
		iTickMode = TICK_BY_TABLE_SEAT;
		bWriteScore = false;
		iTableNo = INVAL_TABLE_NO;
		iSeatNo = INVAL_SEAT_NO;
		memset(szName, 0, sizeof(szName));
	}

	int iRes;			// 踢的结果
	int iTickMode;		// 踢的方式，参考 TICK_BY_TABLE_SEAT 等
	bool bWriteScore;	// 踢完后是否写金币变化值
	int	iTableNo;		// 被踢的桌号
	int	iSeatNo;		// 被踢的座号

	char szName[USER_NAME_LEN];			// 用户名
};

// 拼网络延迟
struct CMD_NET_GAP_TIME
{
	CMD_NET_GAP_TIME()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		llUserID;				// 用户ID
	long long		llSendTime;				// 发送时间
};

// 排队
struct CMD_USER_ARRANGE_QUEUE_LIST
{
	CMD_USER_ARRANGE_QUEUE_LIST()
	{
		memset(this, 0, sizeof(*this));
	}
	long long	lUserId;				// 用户ID
	long long	lChannelNo;				// 用户通道
};

// 排队完成
struct CMD_USER_ARRANGE_QUEUE_FINISH
{
	CMD_USER_ARRANGE_QUEUE_FINISH()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRet;				// 排队状态
};

// 取消排队完成
struct CMD_USER_CANCEL_ARRANGE_QUEUE_FINISH
{
	CMD_USER_CANCEL_ARRANGE_QUEUE_FINISH()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRet;				// 取消状态
};

//OnAntiAddiction是否启用防沉迷
struct CMD_Anti_Addiction
{
	CMD_Anti_Addiction()
	{
		memset(this, 0, sizeof(*this));
	}
	bool bIsAntiAddiction;
};

// 在线房间用户数量
struct CMD_RoomUserCount
{
	CMD_RoomUserCount()
	{
		memset(this, 0, sizeof(*this));
	}
	int iRoomUserCount;								// 房间人数
	int iArrangeQueueCount;							// 排队人数
};

// 聊天信息
struct CMD_ChatContent
{
	CMD_ChatContent()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iChatType;							// 聊天类型(0=普通广播; 1=GM对用户警告; 2...(如充值消息广播、等等))
	long long		lSpeakUserId;						// 说话用户ID
	char			szSpeakNickName[USER_NAME_LEN];		// 说话人昵称
	char			szCentent[CHAT_CONTENT_LEN];		// 聊天内容
};

// 管理员对用户聊天
struct CMD_MrgTalkToUserId
{
	CMD_MrgTalkToUserId()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		lTalkToUserId;						// 对用户的ID
	CMD_ChatContent chatContent;						// 聊天信息
};

// 管理员对用户聊天返回
struct CMD_MrgTalkToUserIdRes
{
	CMD_MrgTalkToUserIdRes()
	{
		memset(this, 0, sizeof(*this));
	}
	int				iRes;// 0:消息发送成功; 1:用户不存在
	char			szText[RESULT_TEXT_LEN];			// 返回内容
};

// 
struct CMD_GetUserData
{
	CMD_GetUserData()
	{
		memset(this, 0, sizeof(*this));
	}

	int				iGameId;			// 游戏ID
	long long		lUserId;			// 用户ID
};

// 任务完成
struct CMD_UserTaskFinish
{
	CMD_UserTaskFinish()
	{
		memset(this, 0, sizeof(*this));
	}
	long long		lUserId;			// 用户ID
	int				iTaskId;			// 任务ID
};

// 踢出用户
struct CMD_KickOutUser
{
	CMD_KickOutUser()
	{
		memset(this, 0, sizeof(*this));
	}
	int		iRet;			// 踢出原因
};

// 踢出用户
struct CMD_KickOutInfo
{
	CMD_KickOutInfo()
	{
		memset(this, 0, sizeof(*this));
	}
	int		iMode;			// 0:用户;1:桌子;2:房间
	long long		iData;			// 对应iMode=0:用户Id;1:桌子Id;2:房间Id）
};

// 写入房间用户人数		// version: 20140423
struct CMD_WriteUserCount
{
	CMD_WriteUserCount()
	{
		memset(this, 0, sizeof(*this));
	}
	int iRoomId;		// 房间ID
	int iPeople;		// 房间人数
};

// 设置是否允许指定的保单机打印保单纸
struct CMD_AllowCCPPMPrint
{
	CMD_AllowCCPPMPrint()
	{
		memset(this, 0, sizeof(*this));
	}
	int id;
	char szMachineCode[33];
	bool bAllowed;
};

// 设置是否允许指定的保单机打印保单纸 返回数据
struct CMD_AllowCCPPMPrint_Ret
{
	CMD_AllowCCPPMPrint_Ret()
	{
		memset(this, 0, sizeof(*this));
	}
	char szMachineCode[33];
	bool bAllowed;
	bool bSuccessed;
};
typedef std::map<int, CMD_AllowCCPPMPrint> CCPPM_MAP;

class finder
{
public:
	finder(const char *cmp_string) :m_s_cmp_string(cmp_string){}
	bool operator ()(const CCPPM_MAP::value_type &pair)
	{
#ifdef WIN32
		return !_stricmp(pair.second.szMachineCode, m_s_cmp_string);
#else
		return !strcasecmp(pair.second.szMachineCode, m_s_cmp_string);
#endif
	}
private:
	const char *m_s_cmp_string;
};

// @xxye add 龙虎详细记录每盘下注额记录表
struct CMD_LongHuDetailRecord
{
	CMD_LongHuDetailRecord() { memset(this, 0, sizeof(*this)); }

	int	iRoomId;			// 房间ID
	long long	lUserId;	// 用户ID
	int	iTableNo;			// 桌子号
	int nRoundNo;			// 局数
	int nPlayNo;			// 盘数
	long long lLongBetGold;	// 龙
	long long lHuBetGold;	// 虎
	long long lHeBetGold;
	unsigned char cbWin;	// 输赢(0:龙赢;1:虎赢;2:和)
	unsigned char cbTestBetType; //10=龙  11=虎 12=和  21=龙虎 22=龙和 23=虎和 30=龙虎和
	long long lPureProfit;		// 纯利润

};

// @xxye add 20141118 房间桌子信息
struct CMD_TableGradeInfo
{
	CMD_TableGradeInfo() { memset(this, 0, sizeof(*this)); }
	int  id;						//房间内桌子等级id
	int iTableGradeType;	//桌子等级名字初级中级高级
	int iRoomId;				//房间ID
	int iTableCount;			//房间桌子数
	long long lMinGold;			//最小下注额
	long long lMidGold;
	long long lMaxGold;			//最大下注额
	long long lLimitRedGold;		//限红 龙虎 下注差，每个等级不同
	long long lDoorSill;

	int  iCanEnter;				// 1允许进入
	int  iAutoOpen;				// 1启用自动开启
	EASY_DATA_TIME dtAutoOpenTime;  // 自动开始时间
	int  iAutoClose;				// 启用自动关闭
	EASY_DATA_TIME dtAutoCloseTime;	// 自动关闭时间

};
// @xxye end


// @xxye add 20141119 桌子信息扩展的，包含限红 最大，最小下注
struct TABLE_INFO_EX
{
	TABLE_INFO_EX()
	{
		memset(this, 0, sizeof(*this));
	}
	unsigned int nTableNo;			//桌号
	int iTableGradeType;			//桌子等级名字初级中级高级
	long long lMinGold;			//最小下注额
	long long lMidGold;
	long long lMaxGold;			//最大下注额
	long long lLimitRedGold;		//限红
};

#ifdef WIN32
#pragma pack(pop)
#else
#pragma pack()
#endif

#endif